home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / SoundAndMusic / cmix / Minc / sym.c < prev    next >
C/C++ Source or Header  |  1991-03-16  |  4KB  |  217 lines
  1.  
  2. /*
  3. *   this file contains the symbol table management routines:
  4. *     struct symbol* install (name,scope,type) 
  5. *     struct symbol* new     (name)
  6. *     struct symbol* lookup  (name)
  7. *     char*          strsave (name)
  8. *                    kill_scope (scope)
  9. *                    free_node  (symptr) 
  10. *                    hash       (name)
  11. *                    newscope ()
  12. */
  13. #include <stdio.h>
  14. #include "defs.h"
  15.  
  16. struct symbol *htab[HASHSIZE] = {0};    /* hash table */
  17.  
  18. static struct str {            /* string table */
  19.     char *str;            /* string */
  20.     struct str *next;        /* next entry */
  21. } *stab[HASHSIZE] = {0};
  22.  
  23. static struct symbol *freelist = NULL;    /* free list of unused entries */
  24.  
  25. /*
  26. *   remove all entries of the scope from the symbol table
  27. */
  28. kill_scope (scope)
  29. int scope;
  30. {
  31.     register int i;
  32.     register struct symbol *p, **q, *r;
  33.  
  34.     for (i = 0; i < HASHSIZE; i++) {
  35.         q = &htab[i];
  36.         for (p = htab[i]; p; p = r) {
  37.             r = p->next;
  38.                         if (p->scope == scope){
  39.                 *q = p->next;
  40.                 free_node (p);
  41.                                 }
  42.             else
  43.                 q = &p->next;
  44.             }
  45.         }
  46. }
  47.  
  48. /* install - allocate a new entry for name and install it */
  49. struct symbol *install(name,scope,type)
  50. char *name;
  51. int scope,type;
  52. {
  53.     struct symbol *p;
  54.  
  55.     p = new(name);
  56.     p->next = htab[hash(name)];
  57.     p->type = type;
  58.     p->scope = scope;
  59.     htab[hash(name)] = p;
  60.     return (p);
  61. }
  62.  
  63. /* lookup - lookup name, return pointer to entry */
  64. /* WARNING: it can only find symbol if name is a ptr returned by strsave */
  65. struct symbol *lookup(name)
  66. char *name;
  67. {
  68.     struct symbol *p;
  69.  
  70.     for (p = htab[hash(name)]; p != NULL ; p = p->next)
  71.         if (name == p->name)
  72.             return (p);
  73.     return (NULL);
  74. }
  75.  
  76. /* new - allocate and initialize and new symbol table entry for name */
  77. struct symbol *new(name)
  78. char *name;
  79. {
  80.     struct symbol *p;
  81.     char *emalloc();
  82.  
  83.     if (p = freelist)
  84.         freelist = p->next;
  85.     else
  86.         p = (struct symbol *) emalloc(sizeof (struct symbol));
  87.     p->name = name;
  88.     p->type = mktype(T_FLOAT, T_SCALAR);
  89.     p->scope = S_GLOBAL;
  90. /*
  91.     p->defined = p->offset = 0;
  92.     p->list = NULL;
  93. */
  94.     return (p);
  95. }
  96.  
  97. /* strsave - lookup str and install if necessary, return pointer */
  98. char *strsave(str)
  99. char *str;
  100. {
  101.     int h, len;
  102.     char *s, *strcpy();
  103.     struct str *p;
  104.     char *emalloc();
  105.  
  106.     h = 0;
  107.     for (p = stab[hash(str)]; p != NULL ; p = p->next)
  108.         if (strcmp(str, p->str) == 0)
  109.             return (p->str);
  110.     p = (struct str *) emalloc(sizeof(struct str));
  111.     p->str = strcpy(emalloc(strlen(str)+1), str);
  112.     p->next = stab[hash(str)];
  113.     stab[hash(str)] = p;
  114.     return (p->str);
  115. }
  116.  
  117.  
  118. /* free_node  - free storage  for reuse  */
  119. /* is very closely connected to new()    */
  120. /* TBD:  only allow a maximum freelist length */
  121. free_node (p)
  122. struct symbol *p;
  123. {
  124.     if (p==NULL) {
  125.       i_warning (" free_node was called with NULL ptr ");
  126.       return;
  127.     }
  128.  
  129.         if (freelist==NULL)    freelist = p;
  130.         else {
  131.         p->next = freelist;
  132.         freelist = p;
  133.     }
  134.  
  135. }  /*   free_node */
  136.  
  137.  
  138.  
  139. /* dname - return string representation of type, shape, or scope */
  140. char *dname(x)
  141. int x;
  142. {
  143.     static struct tname {
  144.         int val;
  145.         char *name;
  146.     } tnames[] = { T_INT, "int", T_FLOAT, "float", 
  147.         T_COND, "conditional", T_SCALAR, "", T_FUNC, "()",
  148.         T_ARRAY, "[]", S_GLOBAL, "global", S_PARAM, "parameter",
  149.         S_LOCAL, "local", 0, 0 };
  150.     static char buf[30];
  151.     int i;
  152.  
  153.     for (i = 0; tnames[i].name; i++)
  154.         if (tnames[i].val == x)
  155.             return (tnames[i].name);
  156.     sprintf(buf, "<%d>", x);
  157.     return (buf);
  158. }
  159.  
  160. /* dump - print entire symbol table or one entry */
  161. dump(p, fp)
  162. struct symbol *p;
  163. FILE *fp;
  164. {
  165.     int i;
  166.  
  167.     if (fp == NULL)
  168.         fp = stderr;
  169.     if (p == NULL)
  170.         for (i = 0; i < HASHSIZE; i++)
  171.             for (p = htab[i]; p; p = p->next)
  172.                 dump(p, fp);
  173.     else {
  174.         fprintf(fp, "%s ", dname(xtype(p->type)));
  175. /*
  176.         fprintf(fp, "%s%s, %sscope=%s, offset=%d\n", p->name,
  177.             dname(xshape(p->type)),    p->defined?"defined, ":"",
  178.             dname(p->scope), p->offset);
  179. */
  180.         }
  181. }
  182.  
  183.  
  184.  
  185.  
  186. /*  this routine has the error checking for malloc built in */
  187. char *emalloc (i)
  188. int i;
  189. {
  190.     char *s;
  191.         char *malloc ();
  192.  
  193.     s =  malloc (i);
  194.     if (s==NULL) {
  195.         sys_error ("system out of memory");
  196.         exit (1);
  197.     }
  198.     else    return s;
  199. }
  200.  
  201.  
  202. /*
  203. * returns an index to a hash bucket
  204. */
  205. hash (s)
  206. char *s;
  207. {
  208.     int i=0;
  209.  
  210.     while (*s) {
  211.         i =  (((unsigned) *s+i) % HASHSIZE);
  212.         s++;
  213.     }
  214.     return i;
  215. }
  216.  
  217.